import java.util.regex.*;

/**
 * Esta clase es la utilizada para hacer las pruebas que consideramos necesarias
 * a la hora de programar y con las cuestiones que tuvimos algunos problemas.
 * 
 * @author Grupo Kaufmann - Heizenreder - Perales.
 */
public class Prueba{
    
    public static void main(String argv[]){
        String primerArgumento = primerArgumento("reemplazar(como /var* de, <b> /var/ </b>)");
        System.out.println(primerArgumento);
    }

    // da el nombre posta del comando
    public static void nombreComando(){
        String texto = "reemplazar(+/titulo%++, <title> /titulo/ <//title>)";
        String expresionRegular = "[a-zA-Z]*\\(";
        Pattern patron = Pattern.compile(expresionRegular);
        Matcher matcher = patron.matcher(texto);
        if(matcher.find()){
            System.out.println(texto.substring(matcher.start(), matcher.end()-1));
        }
    }

    // obtiene el primer argumento del comando ejecutado
    public static String primerArgumento(String texto){
        String argumento = new String("");
        String expresionRegular = "\\(.*(\\)|,)";
        Pattern patron = Pattern.compile(expresionRegular);
        Matcher matcher = patron.matcher(texto);
        if(matcher.find()){
            argumento = texto.substring(matcher.start()+1, matcher.end()-1);
            argumento = argumento.split(",")[0];
        }
        return argumento;
    }

    // obtiene el segundo argumento del comando ejecutado
    public static void segundoArgumento(){
        String texto = "reemplazar(+/titulo%++, <title> /titulo/ <//title>)";
        String expresionRegular = ", .*\\)";
        Pattern patron = Pattern.compile(expresionRegular);
        Matcher matcher = patron.matcher(texto);
        if(matcher.find()){
            System.out.println(texto.substring(matcher.start()+2, matcher.end()-1));
        }
    }

    // da el nombre posta de la variable utilizando expresiones regulares
    // si no se ingreso una variable devuelve la cadena vacia
    public static void nombreVariablePosta(){
        String texto = "reemplazar(+/title%++, <title> /title/ </title>)";
        String expresionRegular = "/[a-zA-Z]*%";
        Pattern patron = Pattern.compile(expresionRegular);
        Matcher matcher = patron.matcher(texto);
        if(matcher.find()){
            System.out.println(texto.substring(matcher.start()+1, matcher.end()-1));
        }
    }

    public static void comandoReemplazar(){
//         String texto = "Java es un lenguaje de programación orientado";
        String comando = "reemplazar +/title%++,<title> /title/ </title>";
        parsearComando(comando);
    }

    public static void parsearComando(String comando){
//         String orden = comando.split(" ")[0];
        String expresion = comando.split(" ")[1].split(",")[0];
        String reemplazar = comando.split(",")[1];
        // +/title%++
        System.out.println(expresion);
        if(tieneVariable(expresion)){
            String variable = nombreVariable(expresion);
            String expresionRegular = expresionRegularCorrecta(expresion.replace(variable, ""));
            // aca en vez de reemplazar con expresionRegular hay que hacerlo
            // con lo que matchea la expresionRegular a medida que se va
            // desplazando en el texto
            reemplazar = reemplazar.replace("/"+variable+"/", expresionRegular);
            System.out.println(variable+"\n"+expresionRegular+"\n"+reemplazar);
        }
    }

    public static String expresionRegularCorrecta(String seudoEregular){
        String expRegular = "";
        if (seudoEregular.indexOf("/?") != -1){
            expRegular = seudoEregular.replace("/?", "[^\\s^\\t^\\n^\\r^\\.^\\;^\\:^\\_^\\-]");
        }
        else if(seudoEregular.indexOf("/*") != -1){
            expRegular = seudoEregular.replace("/*", "[a-zA-Z[^\\s^\\t^\\n^\\r^\\.^\\;^\\:^\\_^\\-]+]*");
        }
        else if(seudoEregular.indexOf("/%") != -1){
            char caracter = seudoEregular.split("/%")[1].charAt(0);
            expRegular = seudoEregular.replace("/%"+caracter, "[^"+caracter+"]");
        }
        else if(seudoEregular.indexOf("/#") != -1){
            String secuencia = seudoEregular.split("/#")[1];
            expRegular = seudoEregular.replace("/#"+secuencia+"/#", "[a-zA-Z&&[^\""+secuencia+"\"]]*");
        }
        else if(seudoEregular.indexOf("/!") != -1){
            String secuencia = seudoEregular.split("/!")[1];
            expRegular = seudoEregular.replace("/!"+secuencia+"/!", "[a-zA-Z&&[^"+secuencia+"]]*");
        }
        else if(seudoEregular.indexOf("//") != -1){
            expRegular = seudoEregular.replace("//", "/");
        }
        else
            return "";

        expRegular = expRegular.replace("\n", "");
        System.out.println(expRegular);
        return expRegular;
    }

    public static boolean tieneVariable(String expresion){
        char[] opciones = {'?', '*', '%', '$', '!', '/'};
        int indice = expresion.indexOf("/");
        if(indice != -1){
            for(int i = 0; i < opciones.length; i++){
                if(opciones[i] == expresion.charAt(indice+1)){
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    public static String nombreVariable(String expresion){
        String nombreVariable = expresion.split("/")[1];
        String[] opciones = {"?", "*", "%", "$", "!", "/"};
        for(int i = 0; i < opciones.length; i++){
             if(nombreVariable.contains(opciones[i])){
                nombreVariable = nombreVariable.split(opciones[i])[0];
                return nombreVariable;
             }
        }
        return "";
    }

    public static void comandoEliminar(){
        String texto = "El programa Scriptor Version 0.01 esta hecho en Java, con el programa kate y vim, sin utilizar eclipse";
        String expresionRegular = "pr/*a";
        String nuevaExpresionRegular = expresionRegular.replace("/*", "[a-zA-Z[^\\s^\\t^\\n^\\r^\\.^\\;^\\:^\\_^\\-]+]*");
        String textoRemplazado = texto.replaceAll(nuevaExpresionRegular, "");
        System.out.println(expresionRegular);
        System.out.println(nuevaExpresionRegular);
        System.out.println(textoRemplazado);
    }
    
    public static void asterisco(){
        String texto = "asdfsa fsad fasdf asdf";
        String oldExpresionRegular = "as/*a";
        String expresionRegular = oldExpresionRegular.replace("/*", "[a-zA-Z[^\\s^\\t^\\n^\\r^\\.^\\;^\\:^\\_^\\-]+]*");
        System.out.println(expresionRegular);
        Pattern patron = Pattern.compile(expresionRegular);
        Matcher matcher = patron.matcher(texto);

        while(matcher.find()){
            System.out.println(texto.substring(matcher.start(), matcher.end()) + " " + matcher.start() + " " + matcher.end());
        }
    }
}

/*
        /? cualquier caracter que no sea un separador
            - expresion regular [^\\s^\\t^\\n^\\r^\\.^\\;^\\:^\\_^\\-]
        /* cualquier secuencia de caracteres que no incluya separadores
            - expresion regular [a-zA-Z[^\\s^\\t^\\n^\\r^\\.^\\;^\\:^\\_^\\-]+]*
        /%<caracter> cualquier caracter que no sea <caracter>
            - obtener caracter oldExpresionRegular.split("/%")[1].charAt(0);
            - expresion regular "[^"+caracter+"]"
            - reemplazar en cadena "/%"+caracter
        /#<secuencia_de_caracteres>/# cualquier secuencia de caracteres que no
        incluya <secuencia_de_caracteres>
            - obtener secuencia
            - expresion regular
            - reemplazar en cadena
        /!<secuencia_de_caracteres>/! cualquier secuencia de caracteres que no
        incluya ningun caracter de <secuencia_de_caracteres>
        // caracter /
*/
//Canal de la UTN Facultad Regional Santa Fé | http://www.frsf.utn.edu.ar/